package com.drug.mingkang.permission.controller;

import com.drug.mingkang.permission.model.PerModule;
import com.drug.mingkang.permission.model.PerUsers;
import com.drug.mingkang.permission.model.TreeNode;
import com.drug.mingkang.permission.service.PerModuleService;
import com.drug.mingkang.utils.ResponseMessage;
import com.drug.mingkang.utils.Tools;
import com.google.gson.Gson;
import io.swagger.annotations.ApiOperation;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 模块表(PerModule)表控制层
 *
 * @author wenchangjian
 * @since 2020-08-11 12:00:14
 */
@RestController
@RequestMapping("perModule")
public class PerModuleController {
    /**
     * 服务对象
     */
    @Resource
    private PerModuleService perModuleService;

    /**
     * 工具类服务
     */
    @Resource
    private Tools tools;

    /**
     * 返回信息服务
     */
    @Resource
    ResponseMessage responseMessage;

    /**
     * Redis服务
     */
    @Resource
    StringRedisTemplate stringRedisTemplate;

    /**
     * 根据用户查询所有模块
     * @param session 当前会话
     * @return
     */
    @ApiOperation(value = "根据用户查询所有模块", notes = "输入用户id查询所有模块", httpMethod = "POST", response = ResponseMessage.class)
    @ResponseBody
    @PostMapping("findByUserIdModuleAll")
    public  Map<String, Object> findByUserIdModuleAll(HttpSession session){
        PerUsers users = (PerUsers) session.getAttribute("perUsers");
        //查菜单目录按钮
        List<PerModule> list = perModuleService.findByUserIdModuleAllButton(users.getUserId());
        //查菜单目录
        List<PerModule> moduleList = perModuleService.findByUserIdModuleAll(users.getUserId());
        //将这个用户下的模块递归
        List<PerModule> treeByUserId = getTreeByUserId(moduleList);
        Map<String, Object> map = new ConcurrentHashMap<>(1);
        map.put("code", 0);
        map.put("msg", "查询成功");
        //遍历完成树结构 首页
        map.put("data",treeByUserId);
        //方便授权(权限树)
        map.put("moduleList", list);
        //权限树（查看当前登录用户有哪些权限）
        map.put("moduleTree", getTreeByUserId(list));
        return map;
    }

    /**
     * 删除所选模块ID
     * @param moduleIdArr 模块id数组
     * @return
     */
    @PostMapping("/deleteAll")
    @ResponseBody
    @ApiOperation(value = "删除所选模块ID", notes = "输入模块Id数组", httpMethod = "POST", response = ResponseMessage.class)
    public ResponseMessage deleteAll(String[] moduleIdArr){
        //当发生增加修改删除redis所存储的数据删除
        stringRedisTemplate.delete("moduleTree");
        stringRedisTemplate.delete("moduleTreeCheckbox");
        return perModuleService.deleteAll(moduleIdArr);
    }

    /**
     * 删除模块
     * @param moduleId
     * @return
     */
    @ApiOperation(value = "删除模块", notes = "输入模块Id", httpMethod = "POST", response = ResponseMessage.class)
    @ResponseBody
    @PostMapping("deleteModule")
    public ResponseMessage deleteModule(String moduleId){
        //当发生增加修改删除redis所存储的数据删除
        stringRedisTemplate.delete("moduleTree");
        stringRedisTemplate.delete("moduleTreeCheckbox");
       return perModuleService.deleteById(moduleId);
    }

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @PostMapping(value = "/findById")
    @ResponseBody
    public PerModule findById(String id) {
        return this.perModuleService.queryById(id);
    }



    /**
     * 增加模型树 修改模型树
     * @param perModule 接收的数据封装
     */
    @PostMapping("/insertUpdateModule")
    @ResponseBody
    public ResponseMessage insertUpdateModule(PerModule perModule){
        //当发生增加修改删除redis所存储的数据删除
        stringRedisTemplate.delete("moduleTree");
        stringRedisTemplate.delete("moduleTreeCheckbox");
        return perModuleService.insertAndEdit(perModule);
    }



    /**
     * 递归树状模型 (角色选模块 开启按钮)
     * @return
     */
    @ResponseBody
    @PostMapping("/showAllModuleCheckbox")
    public  String  showAllModuleCheckbox(){
        //判断redis是否存在我们所需要的数据
        String moduleTree = stringRedisTemplate.opsForValue().get("moduleTreeCheckbox");
        if (!StringUtils.isEmpty(moduleTree)){
            return moduleTree;
        }else{
//            List<TreeNode> list = returnTree("max");
            //查询 所有有效模块id
            PerModule perModule = new PerModule();
            perModule.setWhetherValid(1);
            //开启按钮
            perModule.setOpenButton(true);
            //查询所有模块递归
            List<PerModule> list = perModuleService.queryAll(perModule);
            List<TreeNode> treeList = tools.getTreeByUserId(list);
            System.out.println(treeList.toString());
            Map<String, Object> map = new HashMap<>(1);
            map.put("code", 0);
            map.put("data", treeList);
            String json = new Gson().toJson(map);
            //将模型树放到redis缓存当中
            stringRedisTemplate.opsForValue().set("moduleTreeCheckbox",json);
            return json;
        }
    }


    /**
     *递归树状模型（没有复选框 模块选模块 关闭按钮）
     * @return
     */
    @ResponseBody
    @PostMapping("/showAllModule")
    public List<TreeNode> showAllModule(){
        //判断redis是否存在我们所需要的数据
        String moduleTree = stringRedisTemplate.opsForValue().get("moduleTree");
        if (!StringUtils.isEmpty(moduleTree)){
            List<TreeNode> TreeNodeList = tools.jsonToList(moduleTree, TreeNode.class);
            return TreeNodeList;
        }else{
            PerModule perModule = new PerModule();
            //查询 所有有效模块id
            perModule.setWhetherValid(1);
            //关闭按钮
            perModule.setOpenButton(false);
            //查询所有模块递归
            List<PerModule> list = perModuleService.queryAll(perModule);
            List<TreeNode> treeList = tools.getTreeByUserId(list);
            //将list转为json存到Redis
            String moduleTree1 = tools.listToJson(treeList);
            stringRedisTemplate.opsForValue().set("moduleTree",moduleTree1);
            return treeList;
        }
    }

    public List<PerModule> getTreeByUserId(List<PerModule> list){
        //创建一个集合
        List<PerModule> list1 = new ArrayList<PerModule>(1);
        //遍历所传进来的集合
        for (PerModule perModule : list) {
            //判断是否为顶级节点max
            if(perModule.getModModuleId().equals("max")){
                //添加导集合当中在寻找顶级节点的子节点
                list1.add(findChildren(perModule,list));
            }
        }
        //返回遍历好的集合
        return list1;
    }


    public PerModule findChildren(PerModule module , List<PerModule> list){
        //遍历集合
        for (PerModule moduleTree : list) {
            //判断子节点的父节点是否与传进来的父节点是否相等
            if(module.getModuleId().equals(moduleTree.getModModuleId())){
                //判断是否为空，为空则添加空子集合
                if(module.getChildren()==null){
                    module.setChildren(new ArrayList<PerModule>());
                }
                //继续遍历当前节点是否还有子节点
                module.getChildren().add(findChildren(moduleTree, list));
            }
        }
        //返回顶级节点下的所有子节点
        return module;
    }


    /**
     * 查询所有模型
     * @return
     */
    @GetMapping("/showListModule")
    @ResponseBody
    public Map<String, Object> showListModule(Integer page, Integer limit, String moduleName,String type){
        Map<String, Object> map = perModuleService.queryAllByLimit(Integer.valueOf(page),Integer.valueOf(limit),moduleName,type);
        return map;
    }

    @GetMapping("/showList")
    @ResponseBody
    public List<PerModule> showList(Integer page, Integer limit, String moduleName){
        List<PerModule> perModules = perModuleService.queryAll(new PerModule());
        return perModules;
    }

}